package org.jsola.hr.service.impl;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.jsola.common.DateKit;
import org.jsola.core.Page;
import org.jsola.exception.ParamException;
import org.jsola.hr.constant.CompanySysNoticeStatus;
import org.jsola.hr.constant.ConfigCodeConstants;
import org.jsola.hr.constant.HrConstants;
import org.jsola.hr.dao.ICompanySysNoticeDAO;
import org.jsola.hr.dto.CompanySysNoticeAddDTO;
import org.jsola.hr.dto.CompanySysNoticeOfflineDTO;
import org.jsola.hr.dto.CompanySysNoticeUpdateDTO;
import org.jsola.hr.dto.TaskAddDTO;
import org.jsola.hr.entity.CompanySysNoticeDO;
import org.jsola.hr.entity.EmpInfoDO;
import org.jsola.hr.entity.TaskDO;
import org.jsola.hr.entity.UserReadCompanySysNoticeDO;
import org.jsola.hr.provider.IMessageProviderService;
import org.jsola.hr.provider.ISiteConfigProviderService;
import org.jsola.hr.provider.IUserProviderService;
import org.jsola.hr.query.CompanySysNoticeQuery;
import org.jsola.hr.service.*;
import org.jsola.hr.vo.*;
import org.jsola.message.dto.*;
import org.jsola.user.core.TokenUser;
import org.jsola.user.entity.UnionOpenIdDO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.web.util.HtmlUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.*;
import java.util.stream.Collectors;


/**
 * 公司系统公告信息
 *
 * @author zhr
 */
@Slf4j
@Service("hrCompanySysNoticeServiceImpl")
public class CompanySysNoticeServiceImpl implements ICompanySysNoticeService {

    @Autowired
    private ICompanySysNoticeDAO companySysNoticeDAO;

    @Autowired
    private IEmpInfoService empInfoService;

    @Autowired
    private IUserProviderService userProviderService;

    @Autowired
    private ISiteConfigProviderService siteConfigProviderService;

    @Autowired
    private IMessageProviderService messageProviderService;

    @Autowired
    private ITaskService taskService;

    @Autowired
    private ThreadPoolTaskScheduler threadPoolTask;

    @Autowired
    private ICompanySysNoticeTaskService companySysNoticeTaskService;

    @Autowired
    private IUserReadCompanySysNoticeService userReadCompanySysNoticeService;

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public CompanySysNoticeVO save(CompanySysNoticeAddDTO companySysNoticeAddDTO, TokenUser tokenUser) {
        // 转DO
        CompanySysNoticeDO companySysNoticeDO = companySysNoticeAddDTO.to(CompanySysNoticeDO.class);

        ParamException.hasText(companySysNoticeDO.getNoticeType(), "请选择通知方式");

        // 立即发布
        if (companySysNoticeAddDTO.getIsPublishNow()) {
            companySysNoticeDO.setPublishDate(new Date());
        } else {
            ParamException.notNull(companySysNoticeDO.getPublishDate(), "非立即发布请选择发布时间");
            if (companySysNoticeDO.getPublishDate().before(new Date())) {
                throw new ParamException("定时发布请不要选择过去的时间点");
            }
        }

        // 反转译标题/内容富文本
        handleRichText(companySysNoticeDO);

        // 根据选择的员工和员工类型,获取最终的发布人员
        getFinalEmpRange(companySysNoticeDO, companySysNoticeAddDTO.getPublishEmpIds(), tokenUser);

        // 发布时间早于当前时间
        companySysNoticeDO.setStatus(CompanySysNoticeStatus.WAIT.getValue());
        if (Objects.nonNull(companySysNoticeDO.getPublishDate()) && companySysNoticeDO.getPublishDate().before(new Date())) {
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.HAS.getValue());
        }
        // 置顶把置顶时间打上,便于查询
        if (companySysNoticeDO.getIsTop()) {
            companySysNoticeDO.setTopDateCreate(new Date());
        }
        // 创建是已上线
        companySysNoticeDO.setIsOnline(true);
        // 创建人名称
        companySysNoticeDO.setCreateUserId(tokenUser.getUserId());
        companySysNoticeDO.setCreateUserName(tokenUser.getUserName());

        // 保存
        companySysNoticeDO = save(companySysNoticeDO, tokenUser.getSiteId(), tokenUser.getUserId());

        // 非立即发布,增加定时任务
        if (companySysNoticeAddDTO.getIsPublishNow()) {
            if (companySysNoticeAddDTO.getIsPublishNow()) {
                List<String> noticeTypeList = Arrays.asList(companySysNoticeAddDTO.getNoticeType().split(","));
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_WECHAT)) {
                    // 微信公众号推送模板消息
                    sendWeiXinTemp(companySysNoticeDO, tokenUser);
                }
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_TEXT)) {
                    // 发送短信
                    sendTextTemp(companySysNoticeDO, tokenUser);
                }
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_EMAIL)) {
                    // 发送邮件
                    sendEmailTemp(companySysNoticeDO, tokenUser);
                }
            }
        } else {
            addTask(companySysNoticeDO, true, tokenUser);
        }

        return companySysNoticeDO.to(CompanySysNoticeVO.class);
    }

    /**
     * 添加定时任务
     *
     * @param companySysNoticeDO 任务信息
     * @param isOnline           上线还是下线
     * @param tokenUser          当前用户
     */
    private void addTask(CompanySysNoticeDO companySysNoticeDO, boolean isOnline, TokenUser tokenUser) {
        // 添加记录,重试系统时加载
        TaskAddDTO taskAddDTO = new TaskAddDTO();
        taskAddDTO.setSubjectType(HrConstants.NOTICE_SUBJECT_TYPE_COMPANY);
        taskAddDTO.setSubjectId(companySysNoticeDO.getId());
        taskAddDTO.setDescription("公司公告定时任务");
        taskAddDTO.setRunBeanName("hrCompanySysNoticeServiceImpl");

        Date runDate;
        if (isOnline) {
            // 上线
            taskAddDTO.setRunType(HrConstants.SYS_NOTICE_ONLINE);
            runDate = companySysNoticeDO.getPublishDate();
        } else {
            // 下线
            taskAddDTO.setRunType(HrConstants.SYS_NOTICE_OFFLINE);
            runDate = companySysNoticeDO.getOfflineDate();
        }
        // 运行时间早于当前时间,用当前时间的下一分钟
        if (runDate == null || runDate.before(new Date())) {
            runDate = DateKit.getBeforeMinute(new Date(), 1);
        }
        taskAddDTO.setRunDate(runDate);
        taskAddDTO.setStatus(false);
        TaskVO taskVO = taskService.save(taskAddDTO, tokenUser);

        // 添加运行定时任务
        Runnable runnable = new companySysNoticeTask(taskVO.getId());
        threadPoolTask.schedule(runnable, runDate);
    }

    public class companySysNoticeTask implements Runnable {
        private String taskId;

        companySysNoticeTask(String taskId) {
            this.taskId = taskId;
        }

        @Override
        public void run() {
            TaskDO task = taskService.selectDOById(taskId, "");
            if (Objects.nonNull(task)) {
                companySysNoticeTaskService.runTask(taskId);
            }
        }
    }

    /**
     * 反转译标题/内容富文本
     *
     * @param companySysNoticeDO 信息
     */
    private void handleRichText(CompanySysNoticeDO companySysNoticeDO) {
        // 富文本反转义
        if (StringUtils.isNotEmpty(companySysNoticeDO.getTitle())) {
            String title = HtmlUtils.htmlUnescape(companySysNoticeDO.getTitle());
            title = title.replaceAll("&nbsp;", " ");
            companySysNoticeDO.setTitle(title);
        }
        if (StringUtils.isNotEmpty(companySysNoticeDO.getContent())) {
            String content = HtmlUtils.htmlUnescape(companySysNoticeDO.getContent());
            content = content.replaceAll("&nbsp;", " ");
            companySysNoticeDO.setContent(content);
        }
        if (StringUtils.isNotEmpty(companySysNoticeDO.getContentHasStyle())) {
            String contentHasStyle = HtmlUtils.htmlUnescape(companySysNoticeDO.getContentHasStyle());
            contentHasStyle = contentHasStyle.replaceAll("&nbsp;", " ");
            companySysNoticeDO.setContentHasStyle(contentHasStyle);
        }
    }

    /**
     * 根据选择的员工和员工类型,获取最终的发布人员
     *
     * @param companySysNoticeDO 信息
     * @param publishEmpIds      发布员工
     * @param tokenUser          当前用户
     */
    private void getFinalEmpRange(CompanySysNoticeDO companySysNoticeDO, String[] publishEmpIds, TokenUser tokenUser) {
        List<EmpInfoDO> empInfoDOList = new ArrayList<>();
        // 全公司
        if (companySysNoticeDO.getPublishEmpRangeIsAll()) {
            // 正式类型
            Integer formalType = companySysNoticeDO.getFormalType();
            List<String> formalTypeList = Collections.singletonList(formalType + "");
            // 公司id
            String companyId = companySysNoticeDO.getCompanyId();
            empInfoDOList = empInfoService.selectOnJobEmpListByFormalTypeAndCompanyIdAndPostType(formalTypeList,
                    companyId, null, tokenUser);
        }
        // 部分员工
        else {
            if (publishEmpIds != null && publishEmpIds.length > 0) {
                empInfoDOList = empInfoService.selectDoByIds(Arrays.asList(publishEmpIds));
            }
        }


        // 符合条件的员工
        ParamException.notEmpty(empInfoDOList, "没有需要发送的员工");
        List<String> finalEmpIdList = empInfoDOList.stream()
                .map(EmpInfoDO::getId)
                .distinct()
                .collect(Collectors.toList());

        List<String> userIdList = empInfoDOList.stream()
                .filter(empInfo -> StringUtils.isNotEmpty(empInfo.getUserId()))
                .distinct()
                .map(EmpInfoDO::getUserId)
                .collect(Collectors.toList());

        ParamException.notEmpty(userIdList, "没有要发送的用户");
        companySysNoticeDO.setFinalEmpIds(String.join(",", finalEmpIdList));
        companySysNoticeDO.setFinalUserIds(String.join(",", userIdList));
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public int update(CompanySysNoticeUpdateDTO companySysNoticeUpdateDTO, TokenUser tokenUser) {

        ParamException.hasText(companySysNoticeUpdateDTO.getNoticeType(), "请选择通知方式");
        CompanySysNoticeDO companySysNoticeOld = selectDOById(companySysNoticeUpdateDTO.getId(), tokenUser.getSiteId());
        ParamException.isFalse(companySysNoticeOld.getIsOnline(), "公告已上线,不能修改,请先下线公告,再进行修改");
        ParamException.isFalse(companySysNoticeOld.getStatus() == 1, "公告已发布,不能修改");

        //转DO
        CompanySysNoticeDO companySysNoticeDO = companySysNoticeUpdateDTO.to(CompanySysNoticeDO.class);
        companySysNoticeDO.setSysNoticeId(companySysNoticeOld.getSysNoticeId());

        // 反转译标题/内容富文本
        handleRichText(companySysNoticeDO);

        // 立即发布
        if (companySysNoticeUpdateDTO.getIsPublishNow()) {
            companySysNoticeDO.setPublishDate(new Date());
        } else {
            ParamException.isFalse(companySysNoticeDO.getPublishDate().before(new Date()), "定时发布请不要选择过去的时间点");
        }
        // 公告状态
        if (Objects.nonNull(companySysNoticeDO.getPublishDate()) && companySysNoticeDO.getPublishDate().before(new Date())) {
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.HAS.getValue());
        }

        // 根据选择的员工和员工类型,获取最终的发布人员
        getFinalEmpRange(companySysNoticeDO, companySysNoticeUpdateDTO.getPublishEmpIds(), tokenUser);
        // 创建人名称
        companySysNoticeDO.setCreateUserName(tokenUser.getUserName());
        // 置顶把置顶时间打上,便于查询
        if (companySysNoticeDO.getIsTop()) {
            companySysNoticeDO.setTopDateCreate(new Date());
        }

        // 非立即发布,增加定时任务
        if (companySysNoticeUpdateDTO.getIsPublishNow()) {
            if (companySysNoticeUpdateDTO.getIsPublishNow()) {
                List<String> noticeTypeList = Arrays.asList(companySysNoticeUpdateDTO.getNoticeType().split(","));
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_WECHAT)) {
                    // 微信公众号推送模板消息
                    sendWeiXinTemp(companySysNoticeDO, tokenUser);
                }
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_TEXT)) {
                    // 发送短信
                    sendTextTemp(companySysNoticeDO, tokenUser);
                }
                if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_EMAIL)) {
                    // 发送邮件
                    sendEmailTemp(companySysNoticeDO, tokenUser);
                }
            }
        } else {
            addTask(companySysNoticeDO, true, tokenUser);
        }

        //根据主键更新，只更新非null值
        return updateByIdSelective(companySysNoticeDO, tokenUser.getSiteId(), tokenUser.getUserId());
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public int deleteByIds(TokenUser tokenUser, String... companySysNoticeIds) {
        for (String id : companySysNoticeIds) {
            CompanySysNoticeDO companySysNoticeOld = selectDOById(id, tokenUser.getSiteId());
            if (companySysNoticeOld.getIsOnline()) {
                throw new ParamException("公告下线后方可删除");
            }
        }
        return logicalDeleteByIds(tokenUser.getSiteId(), tokenUser.getUserId(), (Object[]) companySysNoticeIds);
    }


    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public CompanySysNoticeVO selectById(String companySysNoticeId, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(companySysNoticeId, tokenUser.getSiteId());
        if (companySysNoticeDO == null) {
            return null;
        }
        CompanySysNoticeVO companySysNoticeVO = companySysNoticeDO.to(CompanySysNoticeVO.class);
        // 员工id
        String finalEmpIds = companySysNoticeVO.getFinalEmpIds();
        List<EmpInfoDO> empInfoDOList;
        if (StringUtils.isNotBlank(finalEmpIds)) {
            List<String> empIdList = Arrays.asList(finalEmpIds.split(","));
            empInfoDOList = empInfoService.selectDoByIds(empIdList);
        } else {
            // 正式类型
            Integer formalType = companySysNoticeVO.getFormalType();
            List<String> formalTypeList = Collections.singletonList(formalType + "");
            // 公司id
            String companyId = companySysNoticeVO.getCompanyId();
            // 是否全公司发布
            Boolean publishEmpRangeIsAll = companySysNoticeVO.getPublishEmpRangeIsAll();
            if (publishEmpRangeIsAll) {
                empInfoDOList = empInfoService.selectOnJobEmpListByFormalTypeAndCompanyIdAndPostType(formalTypeList,
                        companyId, null, tokenUser);
            } else {
                // 是否全部员工类型发布(1:全部员工类型,0:部分员工类型)
                Boolean publishEmpTypeIsAll = companySysNoticeVO.getPublishEmpTypeIsAll();
                if (publishEmpTypeIsAll) {
                    empInfoDOList = empInfoService.selectOnJobEmpListByFormalTypeAndCompanyIdAndPostType(formalTypeList,
                            companyId, null, tokenUser);
                } else {
                    // 部分员工类型时选择的员工类型code(用,分隔)
                    String publishEmpType = companySysNoticeVO.getPublishEmpType();
                    String[] split = publishEmpType.split(",");
                    List<String> publishEmpTypeList = Arrays.asList(split);
                    empInfoDOList = empInfoService.selectOnJobEmpListByFormalTypeAndCompanyIdAndPostType(formalTypeList,
                            companyId, publishEmpTypeList, tokenUser);
                }
            }
        }

        // 符合条件的员工
        List<EmpInfoListVO> empInfoListVOS = empInfoDOList.stream()
                .map(empInfoDO -> empInfoDO.to(EmpInfoListVO.class))
                .collect(Collectors.toList());
        companySysNoticeVO.setEmpInfoList(empInfoListVOS);

        return companySysNoticeVO;
    }

    @Override
    public List<CompanySysNoticeListVO> select(CompanySysNoticeQuery companySysNoticeQuery, String siteId) {
        List<CompanySysNoticeDO> companySysNoticeDOList = selectDO(companySysNoticeQuery, siteId);
        if (CollectionUtils.isEmpty(companySysNoticeDOList)) {
            return companySysNoticeDOList == null ? null : new ArrayList<>();
        }
        return companySysNoticeDOList.stream()
                .map(companySysNoticeDO -> companySysNoticeDO.to(CompanySysNoticeListVO.class))
                .collect(Collectors.toList());
    }

    @Override
    public int selectCount(CompanySysNoticeQuery companySysNoticeQuery, String siteId) {
        Example example = buildExample(companySysNoticeQuery, siteId);
        return companySysNoticeDAO.selectCountByExample(example);
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public Page<CompanySysNoticeListVO> selectPage(CompanySysNoticeQuery companySysNoticeQuery, String siteId) {

        Example example = buildExample(companySysNoticeQuery, siteId);
        Page<CompanySysNoticeDO> page = companySysNoticeDAO.selectPageByExample(example,
                companySysNoticeQuery.getPageNo(),
                companySysNoticeQuery.getPageSize());

        return page.to(CompanySysNoticeListVO.class);
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public CompanySysNoticeDO selectDOById(String companySysNoticeId, String siteId) {

        return listById(companySysNoticeId, siteId);
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public List<CompanySysNoticeDO> selectDO(CompanySysNoticeQuery companySysNoticeQuery, String siteId) {

        Example example = buildExample(companySysNoticeQuery, siteId);
        return companySysNoticeDAO.selectByExample(example);
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void onlineNotice(String companySysNoticeId, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(companySysNoticeId, tokenUser.getSiteId());
        ParamException.notNull(companySysNoticeDO, "公司公告不存在或已删除");

        if (companySysNoticeDO.getIsOnline()) {
            throw new ParamException("公告已经是上线状态,不需要重复上线");
        }

        companySysNoticeDO.setIsOnline(true);
        // 下线时间置为null
        companySysNoticeDO.setOfflineDate(null);
        // 根据发布时间更新下公告状态
        if (companySysNoticeDO.getPublishDate().before(new Date())) {
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.HAS.getValue());

            // 更新,公司公告,消息模块都更新
            updateOnOrOfflineByInfo(companySysNoticeDO, true, tokenUser);

            // 微信公众号推送模板消息
            sendWeiXinTemp(companySysNoticeDO, tokenUser);
        } else {
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.WAIT.getValue());
            // 未到上线时刻,添加定时任务
            addTask(companySysNoticeDO, true, tokenUser);

            // 更新只更新公司公告,消息模块不更新,等定时任务
            updateOnOrOfflineByInfo(companySysNoticeDO, false, tokenUser);
        }
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void offlineNotice(String companySysNoticeId, CompanySysNoticeOfflineDTO offlineDTO, TokenUser tokenUser) {

        CompanySysNoticeDO companySysNoticeDO = selectDOById(companySysNoticeId, tokenUser.getSiteId());
        ParamException.notNull(companySysNoticeDO, "公司公告不存在或已删除");

        if (!companySysNoticeDO.getIsOnline()) {
            throw new ParamException("公告已经是下线状态,不需要重复下线");
        }

        if (offlineDTO.getIsOfflineNow()) {
            // 立即下线
            companySysNoticeDO.setOfflineDate(new Date());

            companySysNoticeDO.setIsOnline(false);
            companySysNoticeDO.setIsTop(false);
            companySysNoticeDO.setTopDateCreate(null);
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.OFFLINE.getValue());

            // 更新,公司公告,消息模块都更新
            updateOnOrOfflineByInfo(companySysNoticeDO, true, tokenUser);
        } else {
            ParamException.notNull(offlineDTO.getOfflineDate(), "选择定时下线时请传递下线时间");
            if (offlineDTO.getOfflineDate().before(new Date())) {
                throw new ParamException("定时下线请不要选择过去的时间");
            }
            companySysNoticeDO.setOfflineDate(offlineDTO.getOfflineDate());

            // 下线定时任务
            addTask(companySysNoticeDO, false, tokenUser);

            // 更新只更新公司公告,消息模块不更新,等定时任务
            updateOnOrOfflineByInfo(companySysNoticeDO, false, tokenUser);
        }
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void runOnline(String id, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(id, tokenUser.getSiteId());
        if (Objects.nonNull(companySysNoticeDO)) {
            companySysNoticeDO.setIsOnline(true);
            // 下线时间置为null
            companySysNoticeDO.setOfflineDate(null);
            // 根据发布时间更新下公告状态
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.HAS.getValue());

            // 更新,公司公告,消息模块都更新
            updateOnOrOfflineByInfo(companySysNoticeDO, true, tokenUser);

            List<String> noticeTypeList = Arrays.asList(companySysNoticeDO.getNoticeType().split(","));
            if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_WECHAT)) {
                // 微信公众号推送模板消息
                sendWeiXinTemp(companySysNoticeDO, tokenUser);
            }
            if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_TEXT)) {
                // 发送短信
                sendTextTemp(companySysNoticeDO, tokenUser);
            }
            if (noticeTypeList.contains(HrConstants.NOTICE_TYPE_EMAIL)) {
                // 发送邮件
                sendEmailTemp(companySysNoticeDO, tokenUser);
            }
        }
    }

    /**
     * 发送微信通知
     *
     * @param companySysNoticeDO 系统公告
     * @param tokenUser          当前用户
     */
    private void sendWeiXinTemp(CompanySysNoticeDO companySysNoticeDO, TokenUser tokenUser) {
        String[] empIds = companySysNoticeDO.getFinalEmpIds().split(",");
        if (empIds.length > 0) {
            String id = companySysNoticeDO.getId();
            List<EmpInfoDO> empInfoList = empInfoService.listByIds(tokenUser.getSiteId(), empIds);
            if (!CollectionUtils.isEmpty(empInfoList)) {
                // 用户openId集合
                for (EmpInfoDO empInfo : empInfoList) {
                    // 公众号appid配置
                    String appid = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_APPID,
                            tokenUser.getSiteId());
                    UnionOpenIdDO unionOpenIdDO = userProviderService.getUnionOpenByUserId(appid, empInfo.getUserId());
                    if (Objects.nonNull(unionOpenIdDO) && StringUtils.isNotBlank(unionOpenIdDO.getOpenId())) {
                        // 推送微信模板消息
                        WeiXinDTO weiXinDTO = new WeiXinDTO();
                        weiXinDTO.setAppId(appid);
                        // 通知模板id
                        String templateId = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_COMPANY_EMP_NOTICE_TEMPLATE_ID,
                                tokenUser.getSiteId());
                        weiXinDTO.setTemplateId(templateId);
                        weiXinDTO.setToUser(unionOpenIdDO.getOpenId());
                        // 参数
                        List<WxTemplateParam> paramList = new ArrayList<>();
                        WxTemplateParam param1 = new WxTemplateParam();
                        param1.setName("first");
                        param1.setValue("您有一条新的企业公告，请及时查看");
                        paramList.add(param1);
                        WxTemplateParam param2 = new WxTemplateParam();
                        param2.setName("keyword1");
                        param2.setValue("企业公告");
                        paramList.add(param2);
                        WxTemplateParam param3 = new WxTemplateParam();
                        param3.setName("keyword2");
                        param3.setValue(companySysNoticeDO.getTitle());
                        paramList.add(param3);
                        WxTemplateParam param4 = new WxTemplateParam();
                        param4.setName("keyword3");
                        if (companySysNoticeDO.getContent().length() > 60) {
                            param4.setValue(companySysNoticeDO.getContent().substring(0, 59) + "...");
                        } else {
                            param4.setValue(companySysNoticeDO.getContent());
                        }

                        paramList.add(param4);
                        WxTemplateParam param5 = new WxTemplateParam();
                        param5.setName("remark");
                        param5.setValue("点击查看详情");
                        paramList.add(param5);

                        weiXinDTO.setTemplateParamList(paramList);
                        // 跳转小程序
                        WxMiNiParam wxMiNiParam = new WxMiNiParam();
                        // 小程序appid配置
                        String miniAppid = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_MINI_APPID,
                                tokenUser.getSiteId());
                        // 跳转路径
                        String pagePath = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_PATH_COMPANYNOTICE,
                                tokenUser.getSiteId());
                        wxMiNiParam.setAppid(miniAppid);
                        wxMiNiParam.setPagepath(pagePath + "?id=" + id);
                        weiXinDTO.setMiniProgram(wxMiNiParam);
                        log.info(weiXinDTO.toString());
                        messageProviderService.sendWeChatTempMessage(weiXinDTO, tokenUser);
                    }
                }
            }
        }
    }

    /**
     * 发送短信通知
     *
     * @param companySysNoticeDO 系统公告
     * @param tokenUser          当前用户
     */
    private void sendTextTemp(CompanySysNoticeDO companySysNoticeDO, TokenUser tokenUser) {

        /*String thirdId = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_SMS_TEMPLATE_ID, tokenUser.getSiteId());
        // 短信通知
        List<String> empIdList = Arrays.asList(companySysNoticeDO.getFinalEmpIds().split(","));
        List<EmpInfoDO> empInfoDOList = empInfoService.selectDoByIds(empIdList);
        int size = empInfoDOList.size();
        ShortMessageDTO shortMessageDTO = new ShortMessageDTO();
        shortMessageDTO.setScene("企业公告");
        shortMessageDTO.setThirdId(thirdId);
        // 写入短信内容
        long startTime = System.currentTimeMillis();
        // 阿里云批量发送上限为1000
        int sentMessagesMaxNumber = 1000;
        if (size <= sentMessagesMaxNumber) {
            String phoneNumbers = empInfoDOList.parallelStream()
                    .map(EmpInfoDO::getPhone)
                    .distinct()
                    .collect(Collectors.joining(","));
             shortMessageDTO.setPhone(phoneNumbers);
            messageProviderService.sendShortMessage(shortMessageDTO, tokenUser);
            long endTime = System.currentTimeMillis();
            log.debug("批量发送企业公告{}条短信,耗时{}ms", size, endTime - startTime);
        } else {
            int count = (size + sentMessagesMaxNumber - 1) / sentMessagesMaxNumber;
            List<String> phoneList = new ArrayList<>();
            for (int i = 0; i < count; i++) {
                List<String> phoneNumberList;
                if (i == 0) {
                    phoneNumberList = phoneList.subList(i, sentMessagesMaxNumber);
                } else if (i == count - 1) {
                    phoneNumberList = phoneList.subList(i * sentMessagesMaxNumber, size);
                } else {
                    phoneNumberList = phoneList.subList(i * sentMessagesMaxNumber, (i + 1) * sentMessagesMaxNumber);
                }
                String phoneNumbers = phoneNumberList.parallelStream().collect(Collectors.joining(","));
                 shortMessageDTO.setPhone(phoneNumbers);
                messageProviderService.sendShortMessage(shortMessageDTO, tokenUser);
                long endTime = System.currentTimeMillis();
                log.debug("批量发送企业公告{}条短信,耗时{}ms", phoneNumberList.size(), endTime - startTime);
            }
        }*/
    }

    /**
     * 发送邮件通知
     *
     * @param companySysNoticeDO 系统公告
     * @param tokenUser          当前用户
     */
    private void sendEmailTemp(CompanySysNoticeDO companySysNoticeDO, TokenUser tokenUser) {

        /*String email = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_SENDER_EMAIL, tokenUser.getSiteId());
        // 邮件通知
        List<String> empIdList = Arrays.asList(companySysNoticeDO.getFinalEmpIds().split(","));
        List<EmpInfoDO> empInfoDOList = empInfoService.selectDoByIds(empIdList);
        List<String> emailList = empInfoDOList.parallelStream()
                .map(EmpInfoDO::getEmail)
                .filter(StringUtils::isNotBlank)
                .collect(Collectors.toList());
        EmailDTO emailDTO = new EmailDTO();
        emailDTO.setTemplateId(0L);
        emailDTO.setSenderEmail(email);
        emailDTO.setSubjectNoTemp("企业公告");
        emailDTO.setContentNoTemp(companySysNoticeDO.getContent());
         emailDTO.setToEmailList(emailList);
        messageProviderService.sendEmail(emailDTO, tokenUser);*/
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void runOffline(String id, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(id, tokenUser.getSiteId());
        if (Objects.nonNull(companySysNoticeDO)) {
            // 立即下线
            companySysNoticeDO.setOfflineDate(new Date());

            companySysNoticeDO.setIsOnline(false);
            companySysNoticeDO.setStatus(CompanySysNoticeStatus.OFFLINE.getValue());
            companySysNoticeDO.setIsTop(false);
            companySysNoticeDO.setTopDateCreate(null);

            // 更新,公司公告,消息模块都更新
            updateOnOrOfflineByInfo(companySysNoticeDO, true, tokenUser);
        }
    }

    /**
     * 更新上下线状态
     *
     * @param companySysNoticeDO 消息内容
     * @param upNotice           是否更新消息模块
     * @param tokenUser          当前用户
     */
    private void updateOnOrOfflineByInfo(CompanySysNoticeDO companySysNoticeDO, boolean upNotice, TokenUser tokenUser) {
        // 更新
        updateById(companySysNoticeDO, tokenUser.getSiteId(), tokenUser.getUserId());
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void topNotice(String companySysNoticeId, TokenUser tokenUser) {

        CompanySysNoticeDO companySysNoticeDO = selectDOById(companySysNoticeId, tokenUser.getSiteId());
        ParamException.notNull(companySysNoticeDO, "公司公告不存在或已删除");

        if (companySysNoticeDO.getIsTop()) {
            throw new ParamException("公告已经是置顶状态,不需要重复置顶");
        }
        if (!companySysNoticeDO.getIsOnline()) {
            throw new ParamException("公告已下线状态,请上线公告后再修改");
        }
        // 置顶加置顶时间
        companySysNoticeDO.setIsTop(true);
        companySysNoticeDO.setTopDateCreate(new Date());
        // 修改信息,全部更新
        updateTopByInfo(companySysNoticeDO, tokenUser);
    }

    @Override
    @Transactional(value = HrConstants.TX, rollbackFor = Exception.class)
    public void upTopNotice(String companySysNoticeId, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(companySysNoticeId, tokenUser.getSiteId());
        ParamException.notNull(companySysNoticeDO, "公司公告不存在或已删除");

        if (!companySysNoticeDO.getIsTop()) {
            throw new ParamException("公告未置顶,不需要取消");
        }
        if (!companySysNoticeDO.getIsOnline()) {
            throw new ParamException("公告已下线状态,请上线公告后再修改");
        }
        // 置顶加置顶时间
        companySysNoticeDO.setIsTop(false);
        companySysNoticeDO.setTopDateCreate(null);
        // 修改信息,全部更新
        updateTopByInfo(companySysNoticeDO, tokenUser);
    }

    private void updateTopByInfo(CompanySysNoticeDO companySysNoticeDO, TokenUser tokenUser) {
        // 更新
        updateById(companySysNoticeDO, tokenUser.getSiteId(), tokenUser.getUserId());
    }

    @Override
    public List<UserCompanySysNoticeListVO> listSysNoticeByUser(CompanySysNoticeQuery companySysNoticeQuery, TokenUser tokenUser) {
        ParamException.hasText(companySysNoticeQuery.getCompanyId(), "请传递公司id");
        // 用户在某公司对应的员工
        EmpInfoDO empInfo = empInfoService.getEmpInfoByCompanyAndUser(companySysNoticeQuery.getCompanyId(), tokenUser.getUserId(), tokenUser.getSiteId());

        // 获取用户相关的公告
        List<CompanySysNoticeDO> companySysNoticeList = listByUser(empInfo, companySysNoticeQuery, tokenUser);
        // 增加已读信息,转vo
        return addReadInfo(companySysNoticeList, tokenUser);
    }

    /**
     * 获取用户相关的公告
     *
     * @param empInfo               员工信息
     * @param companySysNoticeQuery 查询条件
     * @param tokenUser             当前用户
     * @return 用户相关的公告
     */
    private List<CompanySysNoticeDO> listByUser(EmpInfoDO empInfo, CompanySysNoticeQuery companySysNoticeQuery, TokenUser tokenUser) {
        if (Objects.isNull(empInfo)) {
            // 没有员工信息
            return new ArrayList<>();
        }
        // 通用查询条件
        Example example = buildExample(companySysNoticeQuery, tokenUser.getSiteId());
        example.and()
                // 是否已上线(1:已上线,0:未上线)(已上线包含待发布,已发布)
                .andEqualTo("isOnline", true)
                // 公告状态(0:待发布,1:已发布,2:已下线)(待发布,已发布属于已上线)
                .andEqualTo("status", "1");
        // 全公司或者发布人中有此员工
        example.and()
                .andEqualTo("publishEmpRangeIsAll", true)
                .orLike("publishEmpRange", "%" + empInfo.getId() + "%");
        // 员工类型全部或者包含此人员类型
        example.and()
                .andEqualTo("publishEmpTypeIsAll", true)
                .orLike("publishEmpType", "%" + empInfo.getPostType() + "%");
//        // 不是此人员已删除的
//        String srtBu = "id not in(" +
//                " select sys_notice_id from hr_user_read_company_sys_notice " +
//                "  where site_id = '" + tokenUser.getSiteId() + "' " +
//                "    and user_id = '" + tokenUser.getUserId() + "' " +
//                "    and has_del = 1 " +
//                " )";
//        example.and().andCondition(srtBu);

        example.setOrderByClause(" is_top = 1 desc, top_date_create desc, publish_date desc ");
        return companySysNoticeDAO.selectByExample(example);
    }

    /**
     * 增加系统公告已读信息
     *
     * @param companySysNoticeList 公司公告
     * @param tokenUser            当前用户
     * @return 公司公告及已读信息
     */
    private List<UserCompanySysNoticeListVO> addReadInfo(List<CompanySysNoticeDO> companySysNoticeList, TokenUser tokenUser) {
        if (CollectionUtils.isEmpty(companySysNoticeList)) {
            return new ArrayList<>();
        }
        List<UserCompanySysNoticeListVO> sysNoticeVoList = companySysNoticeList.stream()
                .map(notice -> notice.to(UserCompanySysNoticeListVO.class))
                .collect(Collectors.toList());

        String[] sysNoticeIds = sysNoticeVoList.parallelStream()
                .map(UserCompanySysNoticeListVO::getId)
                .toArray(String[]::new);

        // 获取已读的公司公告
        List<UserReadCompanySysNoticeDO> userReadList = userReadCompanySysNoticeService.listBySysNoticeIds(tokenUser, sysNoticeIds);
        // 公司公告与用户已读的关系
        Map<String, String> userReadMap = userReadList.parallelStream().collect(
                Collectors.toMap(
                        UserReadCompanySysNoticeDO::getSysNoticeId,
                        UserReadCompanySysNoticeDO::getId
                )
        );
        // 增加已读
        sysNoticeVoList.parallelStream().forEach(
                sysNotice -> {
                    if (userReadMap.containsKey(sysNotice.getId())) {
                        sysNotice.setReadStatus(true);
                        sysNotice.setUserReadSysNoticeId(userReadMap.get(sysNotice.getId()));
                    } else {
                        sysNotice.setReadStatus(false);
                    }
                }
        );
        return sysNoticeVoList;
    }

    @Override
    public Page<UserCompanySysNoticeListVO> pageSysNoticeByUser(CompanySysNoticeQuery companySysNoticeQuery, TokenUser tokenUser) {
        ParamException.hasText(companySysNoticeQuery.getCompanyId(), "请传递公司id");
        // 用户在某公司对应的员工
        EmpInfoDO empInfo = empInfoService.getEmpInfoByCompanyAndUser(companySysNoticeQuery.getCompanyId(), tokenUser.getUserId(), tokenUser.getSiteId());

        // 分页查询
        PageInfo<CompanySysNoticeDO> pageDoInfo = PageHelper.startPage(companySysNoticeQuery.getPageNo(), companySysNoticeQuery.getPageSize()).doSelectPageInfo(() -> {
            listByUser(empInfo, companySysNoticeQuery, tokenUser);
        });

        List<CompanySysNoticeDO> companySysNoticeList = pageDoInfo.getList();
        List<UserCompanySysNoticeListVO> userCompanySysNoticeList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(companySysNoticeList)) {
            // 获取用户已阅信息等
            userCompanySysNoticeList = addReadInfo(companySysNoticeList, tokenUser);
        }
        return new Page(userCompanySysNoticeList, pageDoInfo.getPageNum(), pageDoInfo.getPageSize(), (int) pageDoInfo.getTotal());
    }

    @Override
    public UserCompanySysNoticeListVO findSysNoticeByUser(String sysNoticeId, TokenUser tokenUser) {
        CompanySysNoticeDO companySysNoticeDO = selectDOById(sysNoticeId, tokenUser.getSiteId());
        ParamException.notNull(companySysNoticeDO, "公司公告不存在或已删除");
        // 用户在某公司对应的员工
        EmpInfoDO empInfo = empInfoService.getEmpInfoByCompanyAndUser(companySysNoticeDO.getCompanyId(), tokenUser.getUserId(), tokenUser.getSiteId());
        ParamException.notNull(empInfo, "当前用户在公告所在公司下没有员工");

        // 发布人员范围是否符合
        if (!companySysNoticeDO.getPublishEmpRangeIsAll()) {
            if (!companySysNoticeDO.getPublishEmpRange().contains(empInfo.getId())) {
                throw new ParamException("没有查看该公司公告的权限,公告员工范围不符合");
            }
        }

        // 发布人员性质是否符合
        if (!companySysNoticeDO.getPublishEmpTypeIsAll()) {
            if (!companySysNoticeDO.getPublishEmpType().contains(empInfo.getPostType().toString())) {
                throw new ParamException("没有查看该公司公告的权限,公告员工性质不符合");
            }
        }

        if (!companySysNoticeDO.getIsOnline() || companySysNoticeDO.getStatus() != 1) {
            throw new ParamException("公司公告状态不正确,未上线或未发布");
        }

        UserCompanySysNoticeListVO userCompanySysNoticeListVO = companySysNoticeDO.to(UserCompanySysNoticeListVO.class);
        // 增加已读信息
        UserReadCompanySysNoticeDO userReadCompanySysNoticeDO = userReadCompanySysNoticeService.findBySysNoticeId(sysNoticeId, tokenUser);
        if (Objects.isNull(userReadCompanySysNoticeDO)) {
            userCompanySysNoticeListVO.setReadStatus(false);
        } else {
            if (userReadCompanySysNoticeDO.getHasDel()) {
                ParamException.notNull(companySysNoticeDO, "公司公告已删除");
            }
            userCompanySysNoticeListVO.setReadStatus(true);
            userCompanySysNoticeListVO.setUserReadSysNoticeId(userReadCompanySysNoticeDO.getId());
        }

        return userCompanySysNoticeListVO;
    }

    @Override
    public List<CompanySysNoticeDO> listBySysNoticeIds(String siteId, String... sysNoticeIds) {
        if (sysNoticeIds == null || sysNoticeIds.length == 0) {
            return null;
        }
        Example example = new Example(CompanySysNoticeDO.class);
        example.and()
                .andIn("id", Arrays.asList(sysNoticeIds))
                .andEqualTo("valid", true)
                .andEqualTo("siteId", siteId);
        return companySysNoticeDAO.selectByExample(example);
    }

    @Override
    public void sendMessageTest(TokenUser tokenUser) {
        // 公众号appid配置
        String appid = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_APPID,
                tokenUser.getSiteId());
        UnionOpenIdDO unionOpenIdDO = new UnionOpenIdDO();
        unionOpenIdDO.setOpenId("oI23G595oDUqAsrkQ8Efd5rICcGU");
        unionOpenIdDO.setUnionId("oAe090yTxf4ssQLILE5MAlxv_7HY");
        unionOpenIdDO.setAppId("wxfcc99b09df20cef6");
        // 推送微信模板消息
        WeiXinDTO weiXinDTO = new WeiXinDTO();
        weiXinDTO.setAppId(appid);
        // 通知模板id
        String TemplateId = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_COMPANY_EMP_NOTICE_TEMPLATE_ID,
                tokenUser.getSiteId());
        weiXinDTO.setTemplateId(TemplateId);
        weiXinDTO.setToUser(unionOpenIdDO.getOpenId());
        // 参数
        List<WxTemplateParam> paramList = new ArrayList<>();
        WxTemplateParam param1 = new WxTemplateParam();
        param1.setName("first");
        param1.setValue("您有一条新的企业公告，请及时查看");
        paramList.add(param1);
        WxTemplateParam param2 = new WxTemplateParam();
        param2.setName("keyword1");
        param2.setValue("企业公告");
        paramList.add(param2);
        WxTemplateParam param3 = new WxTemplateParam();
        param3.setName("keyword2");
        param3.setValue("标题");
        paramList.add(param3);
        WxTemplateParam param4 = new WxTemplateParam();
        param4.setName("keyword3");
        param4.setValue("内容");

        paramList.add(param4);
        WxTemplateParam param5 = new WxTemplateParam();
        param5.setName("remark");
        param5.setValue("点击查看详情");
        paramList.add(param5);

        weiXinDTO.setTemplateParamList(paramList);
        // 跳转小程序
        WxMiNiParam wxMiNiParam = new WxMiNiParam();
        // 小程序appid配置
        String miniAppid = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_MINI_APPID,
                tokenUser.getSiteId());
        // 小程序首页配置
        String pagePath = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_MINI_PAGE_PATH,
                tokenUser.getSiteId());
        wxMiNiParam.setAppid(miniAppid);
        wxMiNiParam.setPagepath(pagePath);
        weiXinDTO.setMiniProgram(wxMiNiParam);
        log.info(weiXinDTO.toString());
        messageProviderService.sendWeChatTempMessage(weiXinDTO, tokenUser);
    }

    @Override
    public void sendMessageTestNoJump(TokenUser tokenUser) {
        // 公众号appid配置
        String appid = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_APPID,
                tokenUser.getSiteId());
        UnionOpenIdDO unionOpenIdDO = new UnionOpenIdDO();
        unionOpenIdDO.setOpenId("oI23G595oDUqAsrkQ8Efd5rICcGU");
        unionOpenIdDO.setUnionId("oAe090yTxf4ssQLILE5MAlxv_7HY");
        unionOpenIdDO.setAppId("wxfcc99b09df20cef6");
        // 推送微信模板消息
        WeiXinDTO weiXinDTO = new WeiXinDTO();
        weiXinDTO.setAppId(appid);
        // 通知模板id
        String TemplateId = siteConfigProviderService.selectValueByCode(ConfigCodeConstants.CODE_COMPANY_EMP_NOTICE_TEMPLATE_ID,
                tokenUser.getSiteId());
        weiXinDTO.setTemplateId(TemplateId);
        weiXinDTO.setToUser(unionOpenIdDO.getOpenId());
        // 参数
        List<WxTemplateParam> paramList = new ArrayList<>();
        WxTemplateParam param1 = new WxTemplateParam();
        param1.setName("first");
        param1.setValue("您有一条新的企业公告，请及时查看");
        paramList.add(param1);
        WxTemplateParam param2 = new WxTemplateParam();
        param2.setName("keyword1");
        param2.setValue("企业公告");
        paramList.add(param2);
        WxTemplateParam param3 = new WxTemplateParam();
        param3.setName("keyword2");
        param3.setValue("标题");
        paramList.add(param3);
        WxTemplateParam param4 = new WxTemplateParam();
        param4.setName("keyword3");
        param4.setValue("内容");

        paramList.add(param4);
        WxTemplateParam param5 = new WxTemplateParam();
        param5.setName("remark");
        param5.setValue("点击查看详情");
        paramList.add(param5);

        weiXinDTO.setTemplateParamList(paramList);
        log.info(weiXinDTO.toString());
        messageProviderService.sendWeChatTempMessage(weiXinDTO, tokenUser);
    }

    /**
     * 根据查询参数，构建example
     *
     * @param companySysNoticeQuery 查询参数
     * @param siteId                所属站点id
     * @return example
     */
    private Example buildExample(CompanySysNoticeQuery companySysNoticeQuery, String siteId) {
        Example example = new Example(CompanySysNoticeDO.class);
        example.and()
                .andEqualTo("valid", true)
                .andEqualTo("siteId", siteId);
        if (companySysNoticeQuery.getCompanyId() != null) {
            example.and().andEqualTo("companyId", companySysNoticeQuery.getCompanyId());
        }
        if (companySysNoticeQuery.getTitle() != null) {
            example.and().andLike("title", "%" + companySysNoticeQuery.getTitle() + "%");
        }
        if (companySysNoticeQuery.getContent() != null) {
            example.and().andEqualTo("content", companySysNoticeQuery.getContent());
        }
        if (companySysNoticeQuery.getContentHasStyle() != null) {
            example.and().andEqualTo("contentHasStyle", companySysNoticeQuery.getContentHasStyle());
        }
        if (companySysNoticeQuery.getPublishUserId() != null) {
            example.and().andEqualTo("publishUserId", companySysNoticeQuery.getPublishUserId());
        }
        if (companySysNoticeQuery.getPublishUserName() != null) {
            example.and().andEqualTo("publishUserName", companySysNoticeQuery.getPublishUserName());
        }
        if (companySysNoticeQuery.getPublishDateStart() != null &&
                companySysNoticeQuery.getPublishDateEnd() != null) {
            example.and().andBetween("publishDate", companySysNoticeQuery.getPublishDateStart(),
                    companySysNoticeQuery.getPublishDateEnd());
        }
        if (companySysNoticeQuery.getPublishEmpRangeIsAll() != null) {
            example.and().andEqualTo("publishEmpRangeIsAll", companySysNoticeQuery.getPublishEmpRangeIsAll());
        }
        if (companySysNoticeQuery.getPublishEmpRange() != null) {
            example.and().andEqualTo("publishEmpRange", companySysNoticeQuery.getPublishEmpRange());
        }
        if (companySysNoticeQuery.getPublishEmpTypeIsAll() != null) {
            example.and().andEqualTo("publishEmpTypeIsAll", companySysNoticeQuery.getPublishEmpTypeIsAll());
        }
        if (companySysNoticeQuery.getPublishEmpType() != null) {
            example.and().andEqualTo("publishEmpType", companySysNoticeQuery.getPublishEmpType());
        }
        if (companySysNoticeQuery.getFinalEmpIds() != null) {
            example.and().andEqualTo("finalEmpIds", companySysNoticeQuery.getFinalEmpIds());
        }
        if (companySysNoticeQuery.getFinalUserIds() != null) {
            example.and().andEqualTo("finalUserIds", companySysNoticeQuery.getFinalUserIds());
        }
        if (companySysNoticeQuery.getOfflineDateStart() != null &&
                companySysNoticeQuery.getOfflineDateEnd() != null) {
            example.and().andBetween("offlineDate", companySysNoticeQuery.getOfflineDateStart(),
                    companySysNoticeQuery.getOfflineDateEnd());
        }
        if (companySysNoticeQuery.getIsTop() != null) {
            example.and().andEqualTo("isTop", companySysNoticeQuery.getIsTop());
        }
        if (companySysNoticeQuery.getTopDateCreateStart() != null &&
                companySysNoticeQuery.getTopDateCreateEnd() != null) {
            example.and().andBetween("topDateCreate", companySysNoticeQuery.getTopDateCreateStart(),
                    companySysNoticeQuery.getTopDateCreateEnd());
        }
        if (companySysNoticeQuery.getIsOnline() != null) {
            example.and().andEqualTo("isOnline", companySysNoticeQuery.getIsOnline());
        }
        if (companySysNoticeQuery.getStatus() != null) {
            example.and().andEqualTo("status", companySysNoticeQuery.getStatus());
        }
        if (companySysNoticeQuery.getCreateUserName() != null) {
            example.and().andEqualTo("createUserName", companySysNoticeQuery.getCreateUserName());
        }
        if (companySysNoticeQuery.getProps() != null) {
            example.and().andEqualTo("props", companySysNoticeQuery.getProps());
        }
        // 排序
        example.orderBy("isTop").desc().orderBy("publishDate").desc().orderBy("gmtCreate").desc();
//        ExampleKit.setExampleOrder(example,companySysNoticeQuery.getOrders());
        return example;
    }
}